/**
 * 数据源获取全局函数
 * 支持通过数据源ID和SQL查询获取数据
 */

// 模拟的数据源配置
const dataSources = {
  'sales_db': {
    name: '销售数据库',
    type: 'mysql',
    description: '公司销售数据源',
    mockData: {
      dimensions: ["产品", "年份", "销售额"],
      source: [
        {产品: "产品A", 年份: "2020", 销售额: 100},
        {产品: "产品A", 年份: "2021", 销售额: 120},
        {产品: "产品A", 年份: "2022", 销售额: 150},
        {产品: "产品B", 年份: "2020", 销售额: 80},
        {产品: "产品B", 年份: "2021", 销售额: 90},
        {产品: "产品B", 年份: "2022", 销售额: 110},
        {产品: "产品C", 年份: "2020", 销售额: 60},
        {产品: "产品C", 年份: "2021", 销售额: 70},
        {产品: "产品C", 年份: "2022", 销售额: 85}
      ]
    }
  },
  'user_db': {
    name: '用户数据库',
    type: 'postgresql',
    description: '用户行为数据源',
    mockData: {
      dimensions: ["地区", "用户数", "活跃度"],
      source: [
        {地区: "华东", 用户数: 1500, 活跃度: 0.85},
        {地区: "华南", 用户数: 1200, 活跃度: 0.78},
        {地区: "华北", 用户数: 1800, 活跃度: 0.92},
        {地区: "西南", 用户数: 800, 活跃度: 0.72},
        {地区: "西北", 用户数: 600, 活跃度: 0.68}
      ]
    }
  },
  'finance_db': {
    name: '财务数据库',
    type: 'oracle',
    description: '公司财务数据源',
    mockData: {
      dimensions: ["月份", "收入", "支出", "利润"],
      source: [
        {月份: "1月", 收入: 50000, 支出: 35000, 利润: 15000},
        {月份: "2月", 收入: 48000, 支出: 32000, 利润: 16000},
        {月份: "3月", 收入: 52000, 支出: 34000, 利润: 18000},
        {月份: "4月", 收入: 55000, 支出: 36000, 利润: 19000},
        {月份: "5月", 收入: 58000, 支出: 38000, 利润: 20000},
        {月份: "6月", 收入: 60000, 支出: 40000, 利润: 20000}
      ]
    }
  }
};

// 数据缓存
const dataCache = new Map();

/**
 * 模拟SQL查询解析器
 * @param {string} sql - SQL查询语句
 * @returns {Object} 解析后的查询条件
 */
function parseSQL(sql) {
  // 简单的SQL解析，支持基本的SELECT和WHERE条件
  const selectMatch = sql.match(/SELECT\s+(.*?)\s+FROM/i);
  const whereMatch = sql.match(/WHERE\s+(.*)/i);
  
  return {
    fields: selectMatch ? selectMatch[1].split(',').map(f => f.trim()) : ['*'],
    conditions: whereMatch ? whereMatch[1] : null
  };
}

/**
 * 应用SQL条件过滤数据
 * @param {Array} data - 原始数据
 * @param {string} conditions - WHERE条件
 * @returns {Array} 过滤后的数据
 */
function applyConditions(data, conditions) {
  if (!conditions) return data;
  
  // 简单的条件解析（实际项目中应该使用更复杂的解析器）
  const conditionParts = conditions.split(/\s+(AND|OR)\s+/i);
  
  return data.filter(item => {
    return conditionParts.every(part => {
      if (part === 'AND' || part === 'OR') return true;
      
      // 解析单个条件，如：销售额 > 100
      const match = part.match(/(\w+)\s*([><=!]+)\s*(['\"]?)([^'\"]*)\3/);
      if (!match) return true;
      
      const [_, field, operator, quote, value] = match;
      const itemValue = item[field];
      
      switch (operator) {
        case '>': return itemValue > parseFloat(value);
        case '<': return itemValue < parseFloat(value);
        case '=': return itemValue == value;
        case '!=': return itemValue != value;
        case '>=': return itemValue >= parseFloat(value);
        case '<=': return itemValue <= parseFloat(value);
        default: return true;
      }
    });
  });
}

/**
 * 数据获取函数
 * @param {string} sourceId - 数据源ID
 * @param {string} sql - SQL查询语句
 * @param {Object} options - 配置选项
 * @returns {Promise<Object>} 返回{source: []}格式的数据
 */
const getDataSource = async function(sourceId, sql, options = {}) {
  const cacheKey = `${sourceId}_${sql}`;
  
  // 检查缓存
  if (dataCache.has(cacheKey) && !options.forceRefresh) {
    console.log(`从缓存获取数据: ${cacheKey}`);
    return dataCache.get(cacheKey);
  }
  
  try {
    // 检查数据源是否存在
    if (!dataSources[sourceId]) {
      throw new Error(`数据源不存在: ${sourceId}`);
    }
    
    const dataSource = dataSources[sourceId];
    console.log(`正在从数据源获取数据: ${sourceId}`, dataSource);
    
    // 模拟网络延迟
    await new Promise(resolve => setTimeout(resolve, options.delay || 500));
    
    // 获取基础数据
    let data = dataSource.mockData.source;
    
    // 解析SQL并应用条件
    if (sql) {
      const parsedSQL = parseSQL(sql);
      data = applyConditions(data, parsedSQL.conditions);
      
      // 字段筛选（简化处理）
      if (!parsedSQL.fields.includes('*')) {
        data = data.map(item => {
          const filteredItem = {};
          parsedSQL.fields.forEach(field => {
            if (item.hasOwnProperty(field)) {
              filteredItem[field] = item[field];
            }
          });
          return filteredItem;
        });
      }
    }
    
    // 构建返回结果
    const result = {
      source: data,
      dimensions: dataSource.mockData.dimensions.filter(dim => 
        data.length === 0 || Object.keys(data[0]).includes(dim)
      ),
      metadata: {
        sourceId: sourceId,
        sql: sql,
        count: data.length,
        timestamp: new Date().toISOString(),
        dataSource: {
          name: dataSource.name,
          type: dataSource.type,
          description: dataSource.description
        }
      }
    };
    
    // 缓存结果
    dataCache.set(cacheKey, result);
    
    console.log(`数据获取成功: ${sourceId}`, result);
    return result;
    
  } catch (error) {
    console.error(`数据获取失败: ${sourceId}`, error);
    throw error;
  }
};

/**
 * 获取可用数据源列表
 * @returns {Array} 数据源列表
 */
const getDataSourceList = function() {
  return Object.keys(dataSources).map(id => ({
    id: id,
    ...dataSources[id]
  }));
};

/**
 * 清除数据缓存
 * @param {string} sourceId - 可选，指定数据源ID
 */
const clearDataSourceCache = function(sourceId = null) {
  if (sourceId) {
    // 清除指定数据源的缓存
    for (const key of dataCache.keys()) {
      if (key.startsWith(sourceId + '_')) {
        dataCache.delete(key);
      }
    }
  } else {
    // 清除所有缓存
    dataCache.clear();
  }
  console.log('数据缓存已清除');
};

/**
 * 测试数据源连接
 * @param {string} sourceId - 数据源ID
 * @returns {Promise<boolean>} 连接是否成功
 */
const testDataSourceConnection = async function(sourceId) {
  try {
    if (!dataSources[sourceId]) {
      throw new Error(`数据源不存在: ${sourceId}`);
    }
    
    // 模拟连接测试
    await new Promise(resolve => setTimeout(resolve, 200));
    
    console.log(`数据源连接测试成功: ${sourceId}`);
    return true;
    
  } catch (error) {
    console.error(`数据源连接测试失败: ${sourceId}`, error);
    return false;
  }
};

// 导出数据源函数对象
export const datasource = {
  getDataSource,
  getDataSourceList,
  clearDataSourceCache,
  testDataSourceConnection
};

console.log('数据源获取函数已导出');